package cn.fbs.util;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.Random;
/**
 * @program: springbootdemo
 * @description: 字符串工具类
 * @author: wxk
 * @create: 2020-12-21 19:45
 **/
public class StringUtil
{
    /**
     * 左边补齐
     */
    public static final String L="L";
    /**
     * 右边补齐
     */
    public static final String R="R";

    /**
     * 
     * <li>功能描述：把字符串转为url，同时进行utf-8编码，如 “电力” 转换后为：%E7%94%B5%E5%8A%9B
     * 
     * @param s String 原始字符串
     * @return String 转换后的字符串
     * @author wxk
     */
    public static String toURL(String s)
    {
        try
        {
            return URLEncoder.encode(s, "UTF-8");
        } catch (UnsupportedEncodingException e)
        {
            e.printStackTrace();
            return "";
        }
    }

    /**
     * 把一个html的字符串转换成网页上显示的字符串
     * 
     * @param html String 原html格式的字符串
     * @return String 转换后网页显示格式的字符串
     * @author wxk
     */
    public static String htmlToWeb(String html)
    {
        if (html == null || html.length() == 0)
        {
            return "";
        }
        char[] c = html.toCharArray();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < c.length; i++)
        {
            switch (c[i])
            {
                case '>':
                    sb.append("&gt;");
                    break;
                case '<':
                    sb.append("&lt;");
                    break;
                case ' ':
                    sb.append("&nbsp;");
                    break;
                case '"':
                    sb.append("&quot;");
                    break;
                case '&':
                    sb.append("&amp;");
                    break;
                case '\n':
                    sb.append("<br>");
                    break;
                default:
                    try
                    {
                        sb.append(c[i]);
                    } catch (Exception ex)
                    {
                    }
            }
        }
        return sb.toString();
    }

    /**
     * 判断一个字符是Ascill字符还是其它字符（如汉，日，韩文字符）
     * 
     * @param c char 需要判断的字符
     * @return boolean, 返回true,Ascill字符
     * @author wxk
     */
    public static boolean isLetter(char c)
    {
        int k = 0x80;
        return c / k == 0 ? true : false;
    }

    /**
     * 得到一个字符串的长度,显示的长度,一个汉字或 日韩文长度为2,英文字符长度为1
     * 
     * @param s String 需要得到长度的字符串
     * @return int 得到的字符串长度
     * @author wxk
     */
    public static int length(String s)
    {
        char[] c = s.toCharArray();
        int len = 0;
        for (int i = 0; i < c.length; i++)
        {
            len++;
            if (!isLetter(c[i]))
            {
                len++;
            }
        }
        return len;
    }

    

    /**
     * <li>功能描述：把一个字符转化成二进制的
     * 
     * @param c char 原字符
     * @return String 二进制的字符
     * @author wxk
     */
    public static String toBin(char c)
    {
        int k = 0x8000;
        StringBuffer sb = new StringBuffer(16);
        for (int i = 0; i < 16; k >>>= 1, i++)
        {
            sb.append(((c & k) != 0) ? 1 : 0);
        }
        return sb.toString();
    }

    /**
     * 
     * <li>功能描述：判断字符串是否为空。
     * @param val String 需要判定的字符串
     * @return boolean true为空/false不为空
     * @author wxk
     */
    public static boolean isEmpty(String val)
    {
        if (val == null || val.equals(""))
        {
            return true;
        }
        return false;
    }
    /**
     * 
    * <li>功能描述：判断字符串是否为数字 
    * @Title: isNumeric 
    * @param str
    * @return  boolean     
    * @author yuanzhenxing
     */
    public static boolean isNumeric(String str) {
        for (int i = str.length(); --i >= 0;) {
            if (!Character.isDigit(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }
    /**
     * 
     * <li>功能描述：判断字符串是否不为空。
     * @param val String 需要判定的字符串
     * @return boolean true不为空/false为空
     * @author wxk
     */
    public static boolean isNotEmpty(String val)
    {
        if (val == null || val.equals(""))
        {
            return false;
        }
        return true;
    }
    
    public static int ignoreIndexOf(String subject,String search){  
        return ignoreIndexOf(subject,search,0);  
    }  
      
    private static int ignoreIndexOf(String subject,String search,int soffset){  
        //当被查找字符串或查找子字符串为空时，抛出空指针异常。  
        if (subject == null || search == null) {  
            throw new NullPointerException("输入的参数为空");  
        }  
        if(soffset>=subject.length() && search.equals("")){  
            return subject.length();  
        }  
        for (int i = soffset; i < subject.length(); i++) {  
            if(subject.regionMatches(true, i, search, 0, search.length())){  
                return i;  
            }  
        }  
        return -1;  
    }  
      
    public static int ignoreLastIndexOf(String subject,String search) {  
        return ignoreLastIndexOf(subject, search, subject.length());  
    }  
      
    private static int ignoreLastIndexOf(String subject,String search,int soffset) {  
        //当被查找字符串或查找子字符串为空时，抛出空指针异常。  
        if (subject == null || search == null) {  
            throw new NullPointerException("输入的参数为空");  
        }  
        if(soffset<=0 && search.equals("")){  
            return 0;  
        }  
        for (int i = soffset; 0 < i; i--) {  
            if(subject.regionMatches(true, i, search, 0, search.length())){  
                return i;  
            }  
        }  
          
        return -1;  
    }
    
    /**
     * 
     * <li>功能描述 全部替换字符串里符合指定内容的为其它内容， 与String类中不同，它使用的不是正则表达式的。
     * 
     * @param strin
     *            源字符串
     * @param regex
     *            需要替换的内容
     * @param replacement
     *            用来替换的内容
     * @return 替换后的内容
     */
    public static String replaceAll(String strin, String regex,
            String replacement)
    {
        StringBuffer sb = new StringBuffer();
        int rbegin = 0;
        int rend = strin.indexOf(regex);
        int rlen = regex.length();
        while (rend >= 0)
        {
            sb.append(strin.substring(rbegin, rend));
            sb.append(replacement);
            rbegin = rend + rlen;
            rend = strin.indexOf(regex, rbegin);
        }
        sb.append(strin.substring(rbegin));
        strin = sb.toString();
        return strin;
    }
    /**
     * 
     * <li>功能描述：将传入的字符串，补上指定的字母，并补足指定的长度。
     * @param inputstr 传入的字符串
     * @param pos1 “L”从左补全，“R”从右补全
     * @param defaultstr 补全的字符，默认为“0”
     * @param leng 需要补足的长度
     * @return
     * String 
     * @author wxk
     */
    public static String patchString(String inputstr, String pos1, String defaultstr, int leng) {
        String return1 = "";
        int tmpleng = inputstr.length();
        if (tmpleng >= leng) {
            return1 = inputstr;
        }
        else {
            if (defaultstr.equals("")) {
                defaultstr = "0";

            }
            else {
                defaultstr = defaultstr.substring(0, 1);
            }

            int tbleng = leng - tmpleng; //需要填补的长度 
            for (int i = 0; i < tbleng; i++) {
                return1 += defaultstr;
            }
            if (pos1.toUpperCase().equals("L")) {
                return1 = return1 + inputstr;
            }
            else {
                return1 = inputstr + return1;
            }
        }
        return return1;
    }
    /**
     * 
     * <li>功能描述：生成随机串。
     * @param length 随机串长度
     * @param base 随机串基础字符
     * @return
     * String 
     * @author wxk
     */
    public static String getRandomString(int length, String base) { //length表示生成字符串的长度  
        Random random = new Random();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < length; i++) {
            int number = random.nextInt(base.length());
            sb.append(base.charAt(number));
        }
        return sb.toString();
    }
}
